home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2000 / MacHack 2000.toast / pc / The Hacks / Vertigo / Nub / Port.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-24  |  23.1 KB  |  1,081 lines
  1. #define DISABLE_LOCAL_CALLTRACE        1        // Set to 1 to disable Call Traces for this file.
  2. #define DISABLE_LOCAL_DEBUG            0        // Set to 1 to disable all debugging for this file.
  3. #include "DebugUtils.h"
  4.  
  5. #include <MacMemory.h>
  6. #include <MacWindows.h>
  7. #include <OSUtils.h>
  8. #include <ImageCompression.h>
  9. #include "ContextUtils.h"
  10. #include "GWorld.h"
  11. #include "Nub.h"
  12. #include "Patches.h"
  13. #include "PatchHarness.h"
  14. #include "Port.h"
  15. #include "FlushPort.h"
  16.  
  17.  
  18. extern Boolean    gOkToBlit;
  19.  
  20. #ifdef __cplusplus
  21. extern "C" {
  22. #endif
  23.  
  24. typedef pascal SInt32 (*NQDMiscProcPtr)(SInt32 selector,SInt32 *pb);
  25.  
  26. #pragma options align=mac68k
  27. typedef struct QDPortList
  28. {
  29.     UInt16        count;
  30.     GrafPtr        port[0];
  31. } QDPortList, *QDPortListPtr, **QDPortListHandle;
  32. #pragma options align=reset
  33.  
  34. static Boolean ColorGrafPort(GrafPtr port);
  35. static PortShade *CreatePortShadow(GrafPtr port);
  36. static void DisposePortShadow(PortShade *shade);
  37. static PortShade *FindPortShadow(GrafPtr port);
  38. static GrafPtr FindInQDPortList(PortShade *shade);
  39. static Ptr GetGrafPortBaseAddr(GrafPtr port);
  40. static UInt16 GetGrafPortRowBytes(GrafPtr port);
  41. static QDPortListHandle LMGetPortList(void);
  42. static Boolean ScreenDeviceBaseAddr(Ptr baseAddr);
  43. static Boolean ScreenDevicePort(GrafPtr port);
  44. static void SetGrafPortBaseAddr(GrafPtr port,Ptr baseAddr);
  45. static void SetGrafPortRowBytes(GrafPtr port,UInt16 rowBytes);
  46.  
  47. static pascal void StdArcPatch(GrafVerb verb,Rect *rect,short startAngle,short arcAngle);
  48. static pascal void StdBitsPatch(BitMap *srcMap,Rect *srcRect,Rect *dstRect,short mode,RgnHandle maskRgn);
  49. static pascal void StdLinePatch(Point endPoint);
  50. static pascal void StdOvalPatch(GrafVerb verb,Rect *rect);
  51. static pascal void StdPixPatch(PixMap *src,Rect *srcRect,MatrixRecord *matrix,short mode,RgnHandle mask,PixMap *matte,Rect *matteRect,short flags);
  52. static pascal void StdPolyPatch(GrafVerb verb,PolyHandle poly);
  53. static pascal void StdRectPatch(GrafVerb verb,Rect *rect);
  54. static pascal void StdRgnPatch(GrafVerb verb,RgnHandle rgn); 
  55. static pascal void StdRRectPatch(GrafVerb verb,Rect *rect,short width,short height);
  56. static pascal void StdTextPatch(short count,Ptr text,Point numer,Point denom);
  57.  
  58. typedef class StScreenBuffer
  59. {
  60.     private:
  61.         Ptr            fOldBaseAddr;
  62.         UInt16        fOldRowBytes;
  63.         GrafPtr        fPort;
  64.         
  65.     public:
  66.         StScreenBuffer(GrafPtr port,CGrafPtr buffer) : fPort(port)
  67.         {
  68.             fOldBaseAddr = GetGrafPortBaseAddr(fPort);
  69.             fOldRowBytes = GetGrafPortRowBytes(fPort);
  70.             SetGrafPortBaseAddr(fPort,GetGrafPortBaseAddr((GrafPtr)buffer));
  71.             SetGrafPortRowBytes(fPort,(GetGrafPortRowBytes((GrafPtr)buffer) & ~0xC001) | (fOldRowBytes & 0xC001));
  72.         }
  73.         
  74.         ~StScreenBuffer(void)
  75.         {
  76.             SetGrafPortBaseAddr(fPort,fOldBaseAddr);
  77.             SetGrafPortRowBytes(fPort,fOldRowBytes);
  78.         }
  79. } StScreenBuffer;
  80.  
  81. #ifdef __cplusplus
  82. }
  83. #endif
  84.  
  85.  
  86.  
  87.  
  88.  
  89. extern NubInfo                        *gInfo;
  90. extern RoutineDescriptor            gCopyBitsPatchRD;
  91. static RoutineDescriptor            gStdArcRD = BUILD_ROUTINE_DESCRIPTOR(uppQDArcProcInfo,StdArcPatch);
  92. static RoutineDescriptor            gStdBitsRD = BUILD_ROUTINE_DESCRIPTOR(uppQDBitsProcInfo,StdBitsPatch);
  93. static RoutineDescriptor            gStdLineRD = BUILD_ROUTINE_DESCRIPTOR(uppQDLineProcInfo,StdLinePatch);
  94. static RoutineDescriptor            gStdOvalRD = BUILD_ROUTINE_DESCRIPTOR(uppQDOvalProcInfo,StdOvalPatch);
  95. static RoutineDescriptor            gStdPixRD = BUILD_ROUTINE_DESCRIPTOR(uppQDPixProcInfo,StdPixPatch);
  96. static RoutineDescriptor            gStdPolyRD = BUILD_ROUTINE_DESCRIPTOR(uppQDPolyProcInfo,StdPolyPatch);
  97. static RoutineDescriptor            gStdRectRD = BUILD_ROUTINE_DESCRIPTOR(uppQDRectProcInfo,StdRectPatch);
  98. static RoutineDescriptor            gStdRgnRD = BUILD_ROUTINE_DESCRIPTOR(uppQDRgnProcInfo,StdRgnPatch);
  99. static RoutineDescriptor            gStdRRectRD = BUILD_ROUTINE_DESCRIPTOR(uppQDRRectProcInfo,StdRRectPatch);
  100. static RoutineDescriptor            gStdTextRD = BUILD_ROUTINE_DESCRIPTOR(uppQDTextProcInfo,StdTextPatch);
  101. static UInt32                        gPortCount = 0;
  102. static PortShadePtr                    **gPortList = NULL;
  103. static RgnHandle                    gScratchRgn = NULL;
  104. static RgnHandle                    gDirtyRgn = NULL;
  105. static Rect                            *gExtraRect = NULL;
  106.  
  107.  
  108. extern GWorldPtr                    gScreenBuffer = NULL;
  109. extern GWorldPtr                    dropShadowWorld = NULL;
  110. extern GWorldPtr                    preShiftWorld = NULL;
  111. extern GWorldPtr                    scratchWorld = NULL;
  112. extern GWorldPtr                    postShiftWorld = NULL;
  113.  
  114. GWorldPtr                            gStageBuffer = NULL;
  115.  
  116.  
  117.  
  118. OSStatus InitializePorts(void)
  119. {
  120.     OSStatus    err;
  121.     
  122.     
  123.     gPortList = (PortShadePtr**)NewHandle(0);
  124.     dAssert(gPortList != NULL);
  125.     if (gPortList == NULL)
  126.         return memFullErr;
  127.     
  128.     gScreenBuffer = CreateGWorld(&(GetMainDevice())[0]->gdRect);
  129.     dAssert(gScreenBuffer != NULL);
  130.     if (gScreenBuffer == NULL)
  131.         return memFullErr;
  132.     
  133.     gStageBuffer = CreateGWorld(&(GetMainDevice())[0]->gdRect);
  134.     dAssert(gStageBuffer != NULL);
  135.     if (gStageBuffer == NULL)
  136.         return memFullErr;
  137.     
  138.     dropShadowWorld = CreateGWorld(&(GetMainDevice())[0]->gdRect);
  139.     dAssert(dropShadowWorld != NULL);
  140.     if (dropShadowWorld == NULL)
  141.         return memFullErr;
  142.     
  143.     preShiftWorld = CreateGWorld(&(GetMainDevice())[0]->gdRect);
  144.     dAssert(preShiftWorld != NULL);
  145.     if (preShiftWorld == NULL)
  146.         return memFullErr;
  147.     
  148.     scratchWorld = CreateGWorld(&(GetMainDevice())[0]->gdRect);
  149.     dAssert(scratchWorld != NULL);
  150.     if (scratchWorld == NULL)
  151.         return memFullErr;
  152.     
  153.     postShiftWorld = CreateGWorld(&(GetMainDevice())[0]->gdRect);
  154.     dAssert(postShiftWorld != NULL);
  155.     if (postShiftWorld == NULL)
  156.         return memFullErr;
  157.     
  158.     gDirtyRgn = NewRgn();
  159.     gScratchRgn = NewRgn();
  160.     dAssert((gDirtyRgn != NULL) || (gScratchRgn != NULL));
  161.     if ((gDirtyRgn == NULL) || (gScratchRgn == NULL))
  162.         return memFullErr;
  163.     
  164.     SetEmptyRgn(gDirtyRgn);
  165.     RescanPorts();
  166.     
  167.     #if APPBUILD
  168.         PaintBehind((WindowPtr)-1,NULL);
  169.         DrawMenuBar();
  170.     #endif
  171.     
  172.     gOkToBlit = true;
  173.     
  174.     #if APPBUILD
  175.         PaintBehind((WindowPtr)-1,NULL);
  176.         DrawMenuBar();
  177.     #endif
  178.     return noErr;
  179. }
  180.  
  181.  
  182.  
  183.  
  184.  
  185. void FinalizePorts(void)
  186. {
  187.     UInt32    index;
  188.     
  189.     
  190.     if (gDirtyRgn != NULL)
  191.         DisposeRgn(gDirtyRgn);
  192.     
  193.     if (gScratchRgn != NULL)
  194.         DisposeRgn(gScratchRgn);
  195.     
  196. /*
  197.     if (gScreenBuffer != NULL)
  198.         DisposeGWorld(gScreenBuffer);
  199.         
  200.     if (gStageBuffer != NULL)
  201.         DisposeGWorld(gStageBuffer);
  202.         
  203.     if (dropShadowWorld != NULL)
  204.         DisposeGWorld(dropShadowWorld);
  205.         
  206.     if (preShiftWorld != NULL)
  207.         DisposeGWorld(preShiftWorld);
  208.         
  209.     if (scratchWorld != NULL)
  210.         DisposeGWorld(scratchWorld);
  211.         
  212.     if (postShiftWorld != NULL)
  213.         DisposeGWorld(postShiftWorld);
  214. */
  215.         
  216.     if (gPortList != NULL)
  217.     {
  218.         while(gPortCount > 0)
  219.             UnregisterPort((*gPortList)[0]->port,false);
  220.         
  221.         DisposeHandle((Handle)gPortList);
  222.     }
  223.     
  224.     #if APPBUILD
  225.         PaintBehind((WindowPtr)-1,NULL);
  226.         DrawMenuBar();
  227.     #endif
  228. }
  229.  
  230.  
  231.  
  232.  
  233.  
  234. void AddDirtyRect(GrafPtr port,Rect *dirtyRect)
  235. {
  236.     if ((port != *(GrafPtr*)0x9DE) && (port != *(GrafPtr*)0xD2C))
  237.     {
  238.         LocalToGlobal((Point*)&dirtyRect->top);
  239.         LocalToGlobal((Point*)&dirtyRect->bottom);
  240.     }
  241.     
  242.     dirtyRect->right += 3;
  243.     dirtyRect->bottom += 3;
  244.     
  245.     RectRgn(gScratchRgn,dirtyRect);
  246.     UnionRgn(gDirtyRgn,gScratchRgn,gDirtyRgn);
  247. }
  248.  
  249.  
  250.  
  251.  
  252.  
  253. void FlushScreenBuffer(void)
  254. {
  255.     QDBitsUPP    oldBitsProc;
  256.     CGrafPtr    wMgrPort;
  257.     GrafPtr        oldPort;
  258.     RGBColor    oldBackColor,oldForeColor;
  259.     Rect        dirtyRect;
  260.     PortShade    *shade;
  261.     
  262.     GetCWMgrPort(&wMgrPort);
  263.     shade = FindPortShadow((GrafPtr)wMgrPort);
  264.     dAssert(shade != NULL);
  265.     if (shade == NULL)
  266.         return;
  267.     
  268.     // Ugly stuff.
  269.     {
  270.         static UInt32    lastFullBlit = 0;
  271.         UInt32    curTicks = TickCount();
  272.         if (curTicks - lastFullBlit > 60)
  273.         {
  274.             RectRgn(gDirtyRgn,&wMgrPort->portRect);
  275.             lastFullBlit = curTicks;
  276.         }
  277.     }
  278.     
  279.     if (EmptyRgn(gDirtyRgn))
  280.         return;
  281.     
  282.     oldBitsProc = wMgrPort->grafProcs->bitsProc;
  283.     wMgrPort->grafProcs->bitsProc = shade->stdProcs.color.bitsProc;
  284.     
  285.     GetPort(&oldPort);
  286.     SetPort((GrafPtr)wMgrPort);
  287.     GetBackColor(&oldBackColor);
  288.     GetForeColor(&oldForeColor);
  289.     BackColor(whiteColor);
  290.     ForeColor(blackColor);
  291.     
  292.     StRegion    oldClip(wMgrPort->clipRgn);
  293.     StRegion    newClip(wMgrPort->portRect);
  294.     
  295.     SetClip(newClip);
  296.     
  297.     dirtyRect = gDirtyRgn[0]->rgnBBox;
  298.     if (gOkToBlit)
  299.     {
  300.         RenderBufferOntoScreen(gScreenBuffer,(CGrafPtr)wMgrPort,&dirtyRect,gDirtyRgn);
  301.     }
  302.     else
  303.     {
  304.         CopyBits(&((GrafPtr)gScreenBuffer)->portBits,&((GrafPtr)wMgrPort)->portBits,&dirtyRect,
  305.                 &dirtyRect,srcCopy,(gDirtyRgn[0]->rgnSize == 10) ? NULL : gDirtyRgn);
  306.     }
  307.     
  308.     SetClip(oldClip);
  309.     RGBBackColor(&oldBackColor);
  310.     RGBForeColor(&oldForeColor);
  311.     SetPort(oldPort);
  312.     
  313.     wMgrPort->grafProcs->bitsProc = oldBitsProc;
  314.     SetEmptyRgn(gDirtyRgn);
  315. }
  316.  
  317.  
  318.  
  319.  
  320.  
  321. void MungeCopyBits(BitMap *srcMap,BitMap *dstMap,Rect *srcRect,Rect *dstRect,short mode,RgnHandle maskRgn,CopyBitsProcPtr copyBitsProc)
  322. {
  323.     Ptr            oldSrcBaseAddr,srcBaseAddr;
  324.     UInt16        oldSrcRowBytes;
  325.     Boolean        srcScreenDevice = false;
  326.     
  327.     
  328.     if ((*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  329.         CallCopyBitsProc(copyBitsProc,srcMap,dstMap,srcRect,dstRect,mode,maskRgn); 
  330.         return;
  331.     }
  332.     
  333.     // Change all WMgrPorts to CWMgrPorts.
  334.     if (srcMap == &(*(GrafPtr*)0x9DE)->portBits)
  335.         srcMap = &(*(GrafPtr*)0xD2C)->portBits;
  336.     
  337.     if (dstMap == &(*(GrafPtr*)0x9DE)->portBits)
  338.         dstMap = &(*(GrafPtr*)0xD2C)->portBits;
  339.     
  340.     if ((srcMap->rowBytes & 0xC000) == 0xC000)
  341.     {
  342.         // srcMap is CGrafPtr + 2
  343.         if (ScreenDeviceBaseAddr(((PixMapHandle)(srcMap->baseAddr))[0]->baseAddr))
  344.         {
  345.             srcScreenDevice = true;
  346.             oldSrcBaseAddr = ((PixMapHandle)(srcMap->baseAddr))[0]->baseAddr;
  347.             oldSrcRowBytes = ((PixMapHandle)(srcMap->baseAddr))[0]->rowBytes;
  348.             srcBaseAddr = ((PixMapHandle)(srcMap->baseAddr))[0]->baseAddr = GetGrafPortBaseAddr((GrafPtr)gScreenBuffer);
  349.             ((PixMapHandle)(srcMap->baseAddr))[0]->rowBytes = (GetGrafPortRowBytes((GrafPtr)gScreenBuffer) & ~0xC001) | (oldSrcRowBytes & 0xC001);
  350.         }
  351.     }
  352.     else if ((srcMap->rowBytes & 0x8000) == 0x8000)
  353.     {
  354.         // srcMap is PixMap*
  355.         if (ScreenDeviceBaseAddr(((PixMap*)srcMap)->baseAddr))
  356.         {
  357.             srcScreenDevice = true;
  358.             oldSrcBaseAddr = ((PixMap*)srcMap)->baseAddr;
  359.             oldSrcRowBytes = ((PixMap*)srcMap)->rowBytes;
  360.             srcBaseAddr = ((PixMap*)srcMap)->baseAddr = GetGrafPortBaseAddr((GrafPtr)gScreenBuffer);
  361.             ((PixMap*)srcMap)->rowBytes = (GetGrafPortRowBytes((GrafPtr)gScreenBuffer) & ~0xC001) | (oldSrcRowBytes & 0xC001);
  362.         }
  363.     }
  364.     else
  365.     {
  366.         // srcMap is GrafPtr + 2
  367.         if (ScreenDeviceBaseAddr(srcMap->baseAddr))
  368.         {
  369.             srcScreenDevice = true;
  370.             oldSrcBaseAddr = srcMap->baseAddr;
  371.             oldSrcRowBytes = srcMap->rowBytes;
  372.             srcBaseAddr = srcMap->baseAddr = GetGrafPortBaseAddr((GrafPtr)gScreenBuffer);
  373.             srcMap->rowBytes = (GetGrafPortRowBytes((GrafPtr)gScreenBuffer) & ~0xC001) | (oldSrcRowBytes & 0xC001);
  374.         }
  375.     }
  376.     
  377.     if (srcScreenDevice && (srcMap == dstMap))
  378.     {
  379.         GrafPtr    port;
  380.         Rect    dirtyRect;
  381.         
  382.         GetPort(&port);
  383.         dirtyRect = *srcRect;
  384.         AddDirtyRect(port,&dirtyRect);
  385.     }
  386.     
  387.     CallCopyBitsProc(copyBitsProc,srcMap,dstMap,srcRect,dstRect,mode,maskRgn);
  388.     
  389.     if (srcScreenDevice)
  390.     {    
  391.         if ((srcMap->rowBytes & 0xC000) == 0xC000)
  392.         {
  393.             ((PixMapHandle)(srcMap->baseAddr))[0]->baseAddr = oldSrcBaseAddr;
  394.             ((PixMapHandle)(srcMap->baseAddr))[0]->rowBytes = oldSrcRowBytes;
  395.         }
  396.         else if ((srcMap->rowBytes & 0x8000) == 0x8000)
  397.         {
  398.             ((PixMap*)srcMap)->baseAddr = oldSrcBaseAddr;
  399.             ((PixMap*)srcMap)->rowBytes = oldSrcRowBytes;
  400.         }
  401.         else
  402.         {
  403.             srcMap->baseAddr = oldSrcBaseAddr;
  404.             srcMap->rowBytes = oldSrcRowBytes;
  405.         }
  406.     }
  407. }
  408.  
  409.  
  410.  
  411.  
  412.  
  413. void RegisterPort(GrafPtr port)
  414. {
  415.     PortShade    *shade;
  416.     UInt32        size;
  417.     OSStatus    err;
  418.     
  419.     
  420.     dAssert(port != NULL);
  421.     if (port == NULL)
  422.         return;
  423.     
  424.     // Ignore offscreen ports.
  425.     if (!ScreenDevicePort(port))
  426.         return;
  427.     
  428.     // Setup our shadow for this port.
  429.     size = sizeof(PortShadePtr) * gPortCount;
  430.     SetHandleSize((Handle)gPortList,size + sizeof(PortShadePtr));
  431.     err = MemError();
  432.     dAssert(err == noErr);
  433.     if (err != noErr)
  434.         return;
  435.     
  436.     shade = CreatePortShadow(port);
  437.     dAssert(shade != NULL);
  438.     if ((shade == NULL) || (*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  439.         SetHandleSize((Handle)gPortList,size);
  440.         return;
  441.     }
  442.     
  443.     shade->color = ColorGrafPort(port);
  444.     if (shade->color)
  445.     {
  446.         SetStdCProcs(&shade->stdProcs.color);
  447.         shade->procs.color = shade->stdProcs.color;
  448.         ((CGrafPtr)port)->grafProcs = &shade->procs.color;
  449.         
  450.         ((CGrafPtr)port)->grafProcs->arcProc = &gStdArcRD;
  451.         ((CGrafPtr)port)->grafProcs->bitsProc = &gStdBitsRD;
  452.         ((CGrafPtr)port)->grafProcs->lineProc = &gStdLineRD;
  453.         ((CGrafPtr)port)->grafProcs->ovalProc = &gStdOvalRD;
  454.         ((CGrafPtr)port)->grafProcs->newProc1 = &gStdPixRD;
  455.         ((CGrafPtr)port)->grafProcs->polyProc = &gStdPolyRD;
  456.         ((CGrafPtr)port)->grafProcs->rectProc = &gStdRectRD;
  457.         ((CGrafPtr)port)->grafProcs->rgnProc = &gStdRgnRD;
  458.         ((CGrafPtr)port)->grafProcs->rRectProc = &gStdRRectRD;
  459.         ((CGrafPtr)port)->grafProcs->textProc = &gStdTextRD;
  460.     }
  461.     else
  462.     {
  463.         SetStdProcs(&shade->stdProcs.bw);
  464.         shade->procs.bw = shade->stdProcs.bw;
  465.         port->grafProcs = &shade->procs.bw;
  466.     }
  467.     
  468.     (*gPortList)[gPortCount] = shade;
  469.     gPortCount += 1;
  470. }
  471.  
  472.  
  473.  
  474.  
  475.  
  476. void RescanPorts(void)
  477. {
  478.     QDPortListHandle    qdports;
  479.     PortShade            *shade;
  480.     UInt32                index;
  481.     Boolean                rescan;
  482.     
  483.     
  484.     qdports = LMGetPortList();
  485.     dAssert(qdports != NULL);
  486.     if (qdports == NULL)
  487.         return;
  488.     
  489.     for (index = 0;index < qdports[0]->count;index += 1) {
  490.         shade = FindPortShadow(qdports[0]->port[index]);
  491.         if (shade == NULL)
  492.             RegisterPort(qdports[0]->port[index]);
  493.     }
  494.     
  495.     do
  496.     {
  497.         rescan = false;
  498.         for (index = 0;index < gPortCount;index += 1)
  499.             if (FindInQDPortList((*gPortList)[index]) == NULL) {
  500.                 dprintf(kDConPrefix "Manually unregistering port: $%08lX\n",(*gPortList)[index]);
  501.                 UnregisterPort((*gPortList)[index]->port,true);
  502.                 rescan = true;
  503.                 break;
  504.             }
  505.     }while(rescan);
  506. }
  507.  
  508.  
  509.  
  510.  
  511.  
  512. void UnregisterPort(GrafPtr port,Boolean afterTheFact)
  513. {
  514.     PortShade    *shade;
  515.     UInt32        index;
  516.     
  517.     
  518.     dAssert(port != NULL);
  519.     if (port == NULL)
  520.         return;
  521.     
  522.     // Lookup the port in our list and remove its entry if we find it.  We might not find
  523.     // it since we only track GrafPorts that point to a screen device.
  524.     for (index = 0;index < gPortCount;index += 1)
  525.         if ((*gPortList)[index]->port == port)
  526.         {
  527.             gPortCount -= 1;
  528.             shade = (*gPortList)[index];
  529.             
  530.             if (shade->color)
  531.             {
  532.                 ((CGrafPtr)port)->grafProcs = NULL;
  533.             }
  534.             else
  535.             {
  536.                 port->grafProcs = NULL;
  537.             }
  538.             
  539.             BlockMoveData(&(*gPortList)[index + 1],&(*gPortList)[index],(gPortCount - index) * sizeof(PortShadePtr));
  540.             SetHandleSize((Handle)gPortList,gPortCount * sizeof(PortShadePtr));
  541.             DisposePortShadow(shade);
  542.             return;
  543.         }
  544. }
  545.  
  546.  
  547. #if 0
  548. #pragma mark -
  549. #endif
  550.  
  551.  
  552. Boolean ColorGrafPort(GrafPtr port)
  553. {
  554.     dAssert(port != NULL);
  555.     if (port == NULL)
  556.         return NULL;
  557.     
  558.     return ((port->portBits.rowBytes & 0xC000) != 0);
  559. }
  560.  
  561.  
  562.  
  563.  
  564.  
  565. PortShade *CreatePortShadow(GrafPtr port)
  566. {
  567.     PortShade    *shade;
  568.     
  569.     
  570.     dAssert(port != NULL);
  571.     if (port == NULL)
  572.         return NULL;
  573.     
  574.     shade = (PortShade*)NewPtrClear(sizeof(PortShade));
  575.     dAssert(shade != NULL);
  576.     if (shade == NULL)
  577.         return NULL;
  578.     
  579.     shade->port = port;
  580.     return shade;
  581. }
  582.  
  583.  
  584.  
  585.  
  586.  
  587. void DisposePortShadow(PortShade *shade)
  588. {
  589.     dAssert(shade != NULL);
  590.     if (shade == NULL)
  591.         return;
  592.     
  593.     DisposePtr((Ptr)shade);
  594. }
  595.  
  596.  
  597.  
  598.  
  599.  
  600. GrafPtr FindInQDPortList(PortShade *shade)
  601. {
  602.     QDPortListHandle    qdports;
  603.     UInt32                index;
  604.     
  605.     
  606.     dAssert(shade != NULL);
  607.     if (shade == NULL)
  608.         return NULL;
  609.     
  610.     qdports = LMGetPortList();
  611.     dAssert(qdports != NULL);
  612.     if (qdports == NULL)
  613.         return NULL;
  614.     
  615.     for (index = 0;index < qdports[0]->count;index += 1)
  616.         if (qdports[0]->port[index] == shade->port)
  617.             return qdports[0]->port[index];
  618.     
  619.     return NULL;
  620. }
  621.  
  622.  
  623.  
  624.  
  625.  
  626. PortShade *FindPortShadow(GrafPtr port)
  627. {
  628.     for (UInt32 index = 0;index < gPortCount;index += 1)
  629.         if ((*gPortList)[index]->port == port)
  630.             return (*gPortList)[index];
  631.     
  632.     return NULL;
  633. }
  634.  
  635.  
  636.  
  637.  
  638.  
  639. Ptr GetGrafPortBaseAddr(GrafPtr port)
  640. {
  641.     dAssert(port != NULL);
  642.     if (port == NULL)
  643.         return NULL;
  644.     
  645.     if (ColorGrafPort(port))
  646.     {
  647.         return GetPixBaseAddr(((CGrafPtr)port)->portPixMap);
  648.     }
  649.     else
  650.     {
  651.         return port->portBits.baseAddr;
  652.     }
  653. }
  654.  
  655.  
  656.  
  657.  
  658.  
  659. UInt16 GetGrafPortRowBytes(GrafPtr port)
  660. {
  661.     dAssert(port != NULL);
  662.     if (port == NULL)
  663.         return NULL;
  664.     
  665.     if (ColorGrafPort(port))
  666.     {
  667.         return ((CGrafPtr)port)->portPixMap[0]->rowBytes;
  668.     }
  669.     else
  670.     {
  671.         return port->portBits.rowBytes;
  672.     }
  673. }
  674.  
  675.  
  676.  
  677.  
  678.  
  679. QDPortListHandle LMGetPortList(void)
  680. {
  681.     return *(QDPortList***)0xD66;
  682. }
  683.  
  684.  
  685.  
  686.  
  687.  
  688. Boolean ScreenDeviceBaseAddr(Ptr baseAddr)
  689. {
  690.     for (GDHandle gdh = GetDeviceList();gdh != NULL;gdh = GetNextDevice(gdh))
  691.         if ((UInt32)baseAddr == (UInt32)GetPixBaseAddr(gdh[0]->gdPMap))
  692.             return true;
  693.     
  694.     return false;
  695. }
  696.  
  697.  
  698.  
  699.  
  700.  
  701. Boolean ScreenDevicePort(GrafPtr port)
  702. {
  703.     dAssert(port != NULL);
  704.     if (port == NULL)
  705.         return false;
  706.     
  707.     return ScreenDeviceBaseAddr(GetGrafPortBaseAddr(port));
  708. }
  709.  
  710.  
  711.  
  712.  
  713.  
  714. void SetGrafPortBaseAddr(GrafPtr port,Ptr baseAddr)
  715. {
  716.     dAssert((port != NULL) && (baseAddr != NULL));
  717.     if ((port == NULL) || (baseAddr == NULL))
  718.         return;
  719.     
  720.     if (ColorGrafPort(port))
  721.     {
  722.         ((CGrafPtr)port)->portPixMap[0]->baseAddr = baseAddr;
  723.     }
  724.     else
  725.     {
  726.         port->portBits.baseAddr = baseAddr;
  727.     }
  728. }
  729.  
  730.  
  731.  
  732.  
  733.  
  734. void SetGrafPortRowBytes(GrafPtr port,UInt16 rowBytes)
  735. {
  736.     dAssert(port != NULL);
  737.     if (port == NULL)
  738.         return;
  739.     
  740.     if (ColorGrafPort(port))
  741.     {
  742.         ((CGrafPtr)port)->portPixMap[0]->rowBytes = rowBytes;
  743.     }
  744.     else
  745.     {
  746.         port->portBits.rowBytes = rowBytes;
  747.     }
  748. }
  749.  
  750.  
  751. #if 0
  752. #pragma mark -
  753. #endif
  754.  
  755.  
  756. pascal void StdArcPatch(GrafVerb verb,Rect *rect,short startAngle,short arcAngle)
  757. {
  758.     PortShade    *shade;
  759.     GrafPtr        port;
  760.     Rect        dirtyRect;
  761.     
  762.     
  763.     GetPort(&port);
  764.     shade = FindPortShadow(port);
  765.     if (!ScreenDevicePort(port) || (shade == NULL) || (*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  766.         StdArc(verb,rect,startAngle,arcAngle);
  767.         return;
  768.     }
  769.     
  770.     {
  771.         StScreenBuffer    buffer(port,gScreenBuffer);
  772.         
  773.         dirtyRect = *rect;
  774.         dirtyRect.right += 1;
  775.         dirtyRect.bottom += 1;
  776.         InsetRect(&dirtyRect,-port->pnSize.h,-port->pnSize.v);
  777.         AddDirtyRect(port,&dirtyRect);
  778.         CallQDArcProc(shade->stdProcs.color.arcProc,verb,rect,startAngle,arcAngle);
  779.     }
  780.     
  781.     //FlushScreenBuffer();
  782. }
  783.  
  784.  
  785.  
  786.  
  787.  
  788. pascal void StdBitsPatch(BitMap *srcMap,Rect *srcRect,Rect *dstRect,short mode,RgnHandle maskRgn)
  789. {
  790.     PortShade    *shade;
  791.     GrafPtr        dstPort;
  792.     Rect        dirtyRect;
  793.     Ptr            srcBaseAddr;
  794.     
  795.     
  796.     GetPort(&dstPort);
  797.     
  798.     shade = FindPortShadow(dstPort);
  799.     if (!ScreenDevicePort(dstPort) || (shade == NULL) || (*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  800.         StdBits(srcMap,srcRect,dstRect,mode,maskRgn);
  801.         return;
  802.     }
  803.     
  804.     {
  805.         StScreenBuffer    buffer(dstPort,gScreenBuffer);
  806.         
  807.         dirtyRect = *dstRect;
  808.         AddDirtyRect(dstPort,&dirtyRect);
  809.         
  810.         CallQDBitsProc(shade->stdProcs.color.bitsProc,srcMap,srcRect,dstRect,mode,maskRgn);
  811.     }
  812.     
  813.     //if (Button())
  814.     //    FlushScreenBuffer();
  815. }
  816.  
  817.  
  818.  
  819.  
  820.  
  821. pascal void StdLinePatch(Point endPoint)
  822. {
  823.     PortShade    *shade;
  824.     GrafPtr        port;
  825.     Rect        dirtyRect;
  826.     
  827.     
  828.     GetPort(&port);
  829.     shade = FindPortShadow(port);
  830.     if (!ScreenDevicePort(port) || (shade == NULL) || (*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  831.         StdLine(endPoint);
  832.         return;
  833.     }
  834.     
  835.     {
  836.         StScreenBuffer    buffer(port,gScreenBuffer);
  837.         
  838.         dirtyRect.top = port->pnLoc.v;
  839.         dirtyRect.left = port->pnLoc.h;
  840.         dirtyRect.bottom = endPoint.v;
  841.         dirtyRect.right = endPoint.h;
  842.         InsetRect(&dirtyRect,-(port->pnSize.h + 2),-(port->pnSize.v + 2));
  843.         AddDirtyRect(port,&dirtyRect);
  844.         
  845.         CallQDLineProc(shade->stdProcs.color.lineProc,endPoint);
  846.     }
  847.     
  848.     //FlushScreenBuffer();
  849. }
  850.  
  851.  
  852.  
  853.  
  854.  
  855. pascal void StdOvalPatch(GrafVerb verb,Rect *rect)
  856. {
  857.     PortShade    *shade;
  858.     GrafPtr        port;
  859.     Rect        dirtyRect;
  860.     
  861.     
  862.     GetPort(&port);
  863.     shade = FindPortShadow(port);
  864.     if (!ScreenDevicePort(port) || (shade == NULL) || (*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  865.         StdOval(verb,rect);
  866.         return;
  867.     }
  868.     
  869.     {
  870.         StScreenBuffer    buffer(port,gScreenBuffer);
  871.         
  872.         dirtyRect = *rect;
  873.         dirtyRect.right += 1;
  874.         dirtyRect.bottom += 1;
  875.         InsetRect(&dirtyRect,-port->pnSize.h,-port->pnSize.v);
  876.         AddDirtyRect(port,&dirtyRect);
  877.         
  878.         CallQDOvalProc(shade->stdProcs.color.ovalProc,verb,rect);
  879.     }
  880.     
  881.     //FlushScreenBuffer();
  882. }
  883.  
  884.  
  885.  
  886.  
  887.  
  888. pascal void StdPixPatch(PixMap *src,Rect *srcRect,MatrixRecord *matrix,short mode,RgnHandle mask,PixMap *matte,Rect *matteRect,short flags)
  889. {
  890.     PortShade    *shade;
  891.     GrafPtr        port;
  892.     Rect        dirtyRect;
  893.     
  894.     
  895.     GetPort(&port);
  896.     shade = FindPortShadow(port);
  897.     if (!ScreenDevicePort(port) || (shade == NULL)  || (*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  898.         StdPix(src,srcRect,matrix,mode,mask,matte,matteRect,flags);
  899.         return;
  900.     }
  901.     
  902.     dprintf(kDConPrefix "StdPix $%08lX\n",port);
  903.     
  904.     {
  905.         StScreenBuffer    buffer(port,gScreenBuffer);
  906.         
  907.         dirtyRect = *srcRect;
  908.         TransformRect(matrix,&dirtyRect,NULL);
  909.         AddDirtyRect(port,&dirtyRect);
  910.         
  911.         CallStdPixProc(shade->stdProcs.color.newProc1,src,srcRect,matrix,mode,mask,matte,matteRect,flags);
  912.     }
  913.     
  914.     if (Button())
  915.         FlushScreenBuffer();
  916. }
  917.  
  918.  
  919.  
  920.  
  921.  
  922. pascal void StdPolyPatch(GrafVerb verb,PolyHandle poly)
  923. {
  924.     PortShade    *shade;
  925.     GrafPtr        port;
  926.     Rect        dirtyRect;
  927.     
  928.     
  929.     GetPort(&port);
  930.     shade = FindPortShadow(port);
  931.     if (!ScreenDevicePort(port) || (shade == NULL)  || (*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  932.         StdPoly(verb,poly);
  933.         return;
  934.     }
  935.     
  936.     {
  937.         StScreenBuffer    buffer(port,gScreenBuffer);
  938.         
  939.         dirtyRect = poly[0]->polyBBox;
  940.         dirtyRect.right += 1;
  941.         dirtyRect.bottom += 1;
  942.         InsetRect(&dirtyRect,-port->pnSize.h,-port->pnSize.v);
  943.         
  944.         AddDirtyRect(port,&dirtyRect);
  945.         CallQDPolyProc(shade->stdProcs.color.polyProc,verb,poly);
  946.     }
  947.     
  948.     //FlushScreenBuffer();
  949. }
  950.  
  951.  
  952.  
  953.  
  954.  
  955. pascal void StdRectPatch(GrafVerb verb,Rect *rect)
  956. {
  957.     PortShade    *shade;
  958.     GrafPtr        port;
  959.     Rect        dirtyRect;
  960.     
  961.     
  962.     GetPort(&port);
  963.     shade = FindPortShadow(port);
  964.     if (!ScreenDevicePort(port) || (shade == NULL)  || (*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  965.         StdRect(verb,rect);
  966.         return;
  967.     }
  968.     
  969.     {
  970.         StScreenBuffer    buffer(port,gScreenBuffer);
  971.         
  972.         dirtyRect = *rect;
  973.         dirtyRect.right += 1;
  974.         dirtyRect.bottom += 1;
  975.         InsetRect(&dirtyRect,-port->pnSize.h,-port->pnSize.v);
  976.         AddDirtyRect(port,&dirtyRect);
  977.         CallQDRectProc(shade->stdProcs.color.rectProc,verb,rect);
  978.     }
  979.     
  980.     //FlushScreenBuffer();
  981. }
  982.  
  983.  
  984.  
  985.  
  986.  
  987. pascal void StdRgnPatch(GrafVerb verb,RgnHandle rgn)
  988. {
  989.     PortShade    *shade;
  990.     GrafPtr        port;
  991.     Rect        dirtyRect;
  992.     
  993.     
  994.     GetPort(&port);
  995.     shade = FindPortShadow(port);
  996.     if (!ScreenDevicePort(port) || (shade == NULL)  || (*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  997.         StdRgn(verb,rgn);
  998.         return;
  999.     }
  1000.     
  1001.     {
  1002.         StScreenBuffer    buffer(port,gScreenBuffer);
  1003.         
  1004.         dirtyRect = rgn[0]->rgnBBox;
  1005.         dirtyRect.right += 1;
  1006.         dirtyRect.bottom += 1;
  1007.         InsetRect(&dirtyRect,-port->pnSize.h,-port->pnSize.v);
  1008.         AddDirtyRect(port,&dirtyRect);
  1009.         CallQDRgnProc(shade->stdProcs.color.rgnProc,verb,rgn);
  1010.     }
  1011.     
  1012.     //FlushScreenBuffer();
  1013. }
  1014.  
  1015.  
  1016.  
  1017.  
  1018.  
  1019. pascal void StdRRectPatch(GrafVerb verb,Rect *rect,short width,short height)
  1020. {
  1021.     PortShade    *shade;
  1022.     GrafPtr        port;
  1023.     Rect        dirtyRect;
  1024.     
  1025.     
  1026.     GetPort(&port);
  1027.     shade = FindPortShadow(port);
  1028.     if (!ScreenDevicePort(port) || (shade == NULL)  || (*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  1029.         StdRRect(verb,rect,width,height);
  1030.         return;
  1031.     }
  1032.     
  1033.     {
  1034.         StScreenBuffer    buffer(port,gScreenBuffer);
  1035.         
  1036.         dirtyRect = *rect;
  1037.         dirtyRect.right += 1;
  1038.         dirtyRect.bottom += 1;
  1039.         InsetRect(&dirtyRect,-port->pnSize.h,-port->pnSize.v);
  1040.         AddDirtyRect(port,&dirtyRect);        
  1041.         CallQDRRectProc(shade->stdProcs.color.rRectProc,verb,rect,width,height);
  1042.     }
  1043.     
  1044.     //FlushScreenBuffer();
  1045. }
  1046.  
  1047.  
  1048.  
  1049.  
  1050.  
  1051. pascal void StdTextPatch(short count,Ptr text,Point numer,Point denom)
  1052. {
  1053.     PortShade    *shade;
  1054.     GrafPtr        port;
  1055.     FontInfo    finfo;
  1056.     Rect        dirtyRect;
  1057.     
  1058.     
  1059.     GetPort(&port);
  1060.     shade = FindPortShadow(port);
  1061.     if (!ScreenDevicePort(port) || (shade == NULL)  || (*(UInt32*)0xD2C == NULL) || (*(UInt32*)0xD2C == 0xFFFFFFFF)) {
  1062.         StdText(count,text,numer,denom);
  1063.         return;
  1064.     }
  1065.     
  1066.     {
  1067.         StScreenBuffer    buffer(port,gScreenBuffer);
  1068.         
  1069.         GetFontInfo(&finfo);
  1070.         dirtyRect.top = port->pnLoc.v - finfo.ascent;
  1071.         dirtyRect.left = port->pnLoc.h - 1;
  1072.         dirtyRect.bottom = port->pnLoc.v + finfo.descent;
  1073.         dirtyRect.right = port->pnLoc.h + TextWidth(text,0,count) + finfo.widMax;
  1074.         
  1075.         AddDirtyRect(port,&dirtyRect);
  1076.         CallQDTextProc(shade->stdProcs.color.textProc,count,text,numer,denom);
  1077.     }
  1078.     
  1079.     //FlushScreenBuffer();
  1080. }
  1081.